package com.monitor.ui.controller;

import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.control.*;
import javafx.application.Platform;
import javafx.concurrent.Task;

import java.net.URL;
import java.util.ResourceBundle;
import java.util.Random;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * 维护中心控制器
 * 负责系统更新和诊断功能的实现
 */
public class MaintenancePanelController implements Initializable {

    // 系统更新相关组件
    @FXML private TextArea updateDescription;
    @FXML private Label currentVersionLabel;
    @FXML private Button checkUpdateBtn;
    @FXML private Label updateStatusLabel;
    @FXML private ProgressBar updateProgressBar;
    @FXML private TextArea updateLogTextArea;
    @FXML private Button updateBtn;
    
    // 系统诊断相关组件
    @FXML private TextArea diagnosticDescription;
    @FXML private ProgressBar cpuProgressBar;
    @FXML private Label cpuLabel;
    @FXML private ProgressBar memoryProgressBar;
    @FXML private Label memoryLabel;
    @FXML private ProgressBar diskProgressBar;
    @FXML private Label diskLabel;
    @FXML private CheckBox checkConfigCB;
    @FXML private CheckBox checkDatabaseCB;
    @FXML private CheckBox checkNetworkCB;
    @FXML private CheckBox checkUpdateCB;
    @FXML private CheckBox checkLogsCB;
    @FXML private TextArea diagnosticResultTextArea;
    @FXML private Button startDiagnosticBtn;
    
    // 当前版本和最新版本
    private String currentVersion = "1.0.0";
    private String latestVersion = "1.2.0";
    
    // 随机数生成器，用于模拟系统状态
    private Random random = new Random();
    
    @Override
    public void initialize(URL location, ResourceBundle resources) {
        // 初始化当前版本显示
        currentVersionLabel.setText(currentVersion);
        
        // 初始化系统状态
        updateSystemStatus();
        
        // 启动定时更新系统状态的线程
        startSystemStatusUpdater();
    }
    
    /**
     * 更新系统状态显示
     */
    private void updateSystemStatus() {
        // 模拟CPU使用率
        double cpuUsage = random.nextDouble() * 0.5 + 0.1; // 10% - 60%
        cpuProgressBar.setProgress(cpuUsage);
        cpuLabel.setText(String.format("%.1f%%", cpuUsage * 100));
        
        // 模拟内存使用率
        double memoryUsage = random.nextDouble() * 0.4 + 0.3; // 30% - 70%
        memoryProgressBar.setProgress(memoryUsage);
        memoryLabel.setText(String.format("%.1f%%", memoryUsage * 100));
        
        // 模拟磁盘使用率
        double diskUsage = random.nextDouble() * 0.3 + 0.4; // 40% - 70%
        diskProgressBar.setProgress(diskUsage);
        diskLabel.setText(String.format("%.1f%%", diskUsage * 100));
    }
    
    /**
     * 启动系统状态更新线程
     */
    private void startSystemStatusUpdater() {
        Thread statusUpdater = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(5000); // 每5秒更新一次
                    Platform.runLater(this::updateSystemStatus);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        statusUpdater.setDaemon(true); // 设置为守护线程，随主线程退出
        statusUpdater.start();
    }
    
    /**
     * 检查更新按钮点击事件
     */
    @FXML
    private void onCheckUpdateClicked() {
        // 禁用按钮，防止重复点击
        checkUpdateBtn.setDisable(true);
        updateStatusLabel.setText("正在检查更新...");
        
        // 模拟检查更新过程
        Task<Boolean> checkUpdateTask = new Task<Boolean>() {
            @Override
            protected Boolean call() throws Exception {
                // 模拟网络延迟
                Thread.sleep(2000);
                return !currentVersion.equals(latestVersion);
            }
        };
        
        checkUpdateTask.setOnSucceeded(event -> {
            boolean hasUpdate = checkUpdateTask.getValue();
            if (hasUpdate) {
                updateStatusLabel.setText("发现新版本: " + latestVersion);
                updateBtn.setDisable(false);
                updateLogTextArea.setText("版本 " + latestVersion + " 更新日志:\n\n" +
                        "1. 优化系统性能，提高运行速度\n" +
                        "2. 增强网站过滤功能，提高识别准确率\n" +
                        "3. 改进用户界面，提升用户体验\n" +
                        "4. 修复已知问题，提高系统稳定性\n" +
                        "5. 更新内置黑名单库");
            } else {
                updateStatusLabel.setText("系统已是最新版本");
                updateBtn.setDisable(true);
                updateLogTextArea.setText("当前版本: " + currentVersion + "\n没有可用的更新。");
            }
            checkUpdateBtn.setDisable(false);
        });
        
        checkUpdateTask.setOnFailed(event -> {
            updateStatusLabel.setText("检查更新失败，请稍后重试");
            checkUpdateBtn.setDisable(false);
        });
        
        new Thread(checkUpdateTask).start();
    }
    
    /**
     * 立即更新按钮点击事件
     */
    @FXML
    private void onUpdateClicked() {
        // 禁用按钮，防止重复点击
        updateBtn.setDisable(true);
        checkUpdateBtn.setDisable(true);
        updateStatusLabel.setText("正在下载更新...");
        updateProgressBar.setVisible(true);
        updateProgressBar.setProgress(0);
        
        // 模拟更新下载过程
        Task<Void> updateTask = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                for (int i = 0; i <= 100; i += 5) {
                    updateProgress(i / 100.0, 1);
                    Thread.sleep(300); // 模拟下载延迟
                }
                return null;
            }
        };
        
        updateProgressBar.progressProperty().bind(updateTask.progressProperty());
        
        updateTask.setOnSucceeded(event -> {
            updateProgressBar.progressProperty().unbind();
            updateProgressBar.setProgress(1);
            updateStatusLabel.setText("更新已完成，请重启系统");
            
            // 模拟更新完成后的版本变化
            currentVersion = latestVersion;
            currentVersionLabel.setText(currentVersion);
            
            // 显示确认对话框
            Alert alert = new Alert(Alert.AlertType.INFORMATION);
            alert.setTitle("更新完成");
            alert.setHeaderText(null);
            alert.setContentText("系统已更新到版本 " + currentVersion + "，请重启系统以应用更新。");
            alert.showAndWait();
            
            // 重置界面状态
            updateBtn.setDisable(true);
            checkUpdateBtn.setDisable(false);
        });
        
        updateTask.setOnFailed(event -> {
            updateProgressBar.progressProperty().unbind();
            updateProgressBar.setProgress(0);
            updateStatusLabel.setText("更新失败，请稍后重试");
            updateBtn.setDisable(false);
            checkUpdateBtn.setDisable(false);
        });
        
        new Thread(updateTask).start();
    }
    
    /**
     * 开始诊断按钮点击事件
     */
    @FXML
    private void onStartDiagnosticClicked() {
        // 禁用按钮，防止重复点击
        startDiagnosticBtn.setDisable(true);
        diagnosticResultTextArea.clear();
        appendDiagnosticResult("开始系统诊断...");
        
        // 获取选中的诊断项目
        boolean checkConfig = checkConfigCB.isSelected();
        boolean checkDatabase = checkDatabaseCB.isSelected();
        boolean checkNetwork = checkNetworkCB.isSelected();
        boolean checkUpdate = checkUpdateCB.isSelected();
        boolean checkLogs = checkLogsCB.isSelected();
        
        // 模拟诊断过程
        Task<Void> diagnosticTask = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                if (checkConfig) {
                    Thread.sleep(1000);
                    updateMessage("正在检查配置文件...");
                    Thread.sleep(1000);
                    updateMessage("配置文件检查完成: 正常");
                }
                
                if (checkDatabase) {
                    Thread.sleep(1000);
                    updateMessage("正在检查数据库连接...");
                    Thread.sleep(1500);
                    updateMessage("数据库连接检查完成: 正常");
                }
                
                if (checkNetwork) {
                    Thread.sleep(1000);
                    updateMessage("正在检查网络连接...");
                    Thread.sleep(2000);
                    updateMessage("网络连接检查完成: 正常");
                }
                
                if (checkUpdate) {
                    Thread.sleep(1000);
                    updateMessage("正在检查更新服务...");
                    Thread.sleep(1500);
                    updateMessage("更新服务检查完成: 正常");
                }
                
                if (checkLogs) {
                    Thread.sleep(1000);
                    updateMessage("正在检查日志文件...");
                    Thread.sleep(1200);
                    updateMessage("日志文件检查完成: 发现1个警告");
                    Thread.sleep(500);
                    updateMessage("警告: 日志文件过大，建议清理");
                }
                
                Thread.sleep(1000);
                updateMessage("系统诊断完成");
                return null;
            }
        };
        
        diagnosticTask.messageProperty().addListener((observable, oldValue, newValue) -> {
            appendDiagnosticResult(newValue);
        });
        
        diagnosticTask.setOnSucceeded(event -> {
            appendDiagnosticResult("\n诊断结果总结:\n" +
                    "- CPU使用率: " + cpuLabel.getText() + "\n" +
                    "- 内存使用率: " + memoryLabel.getText() + "\n" +
                    "- 磁盘空间使用率: " + diskLabel.getText() + "\n" +
                    "- 系统状态: 良好\n" +
                    "- 建议: 定期清理日志文件，保持系统流畅运行");
            startDiagnosticBtn.setDisable(false);
        });
        
        diagnosticTask.setOnFailed(event -> {
            appendDiagnosticResult("诊断过程中发生错误，请重试");
            startDiagnosticBtn.setDisable(false);
        });
        
        new Thread(diagnosticTask).start();
    }
    
    /**
     * 添加诊断结果到文本区域
     */
    private void appendDiagnosticResult(String message) {
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        String timestamp = now.format(formatter);
        
        Platform.runLater(() -> {
            diagnosticResultTextArea.appendText("[" + timestamp + "] " + message + "\n");
        });
    }
}